home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_decimal.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  32KB  |  945 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """
  5. These are the test cases for the Decimal module.
  6.  
  7. There are two groups of tests, Arithmetic and Behaviour. The former test
  8. the Decimal arithmetic using the tests provided by Mike Cowlishaw. The latter
  9. test the pythonic behaviour according to PEP 327.
  10.  
  11. Cowlishaw's tests can be downloaded from:
  12.  
  13.    www2.hursley.ibm.com/decimal/dectest.zip
  14.  
  15. This test module can be called from command line with one parameter (Arithmetic
  16. or Behaviour) to test each part, or without parameter to test both parts. If
  17. you're working through IDLE, you can import this test module and call test_main()
  18. with the corresponding argument.
  19. """
  20. import unittest
  21. import glob
  22. import os
  23. import sys
  24. import pickle
  25. import copy
  26. from decimal import *
  27. from test.test_support import TestSkipped, run_unittest, run_doctest, is_resource_enabled
  28. import random
  29.  
  30. try:
  31.     import threading
  32. except ImportError:
  33.     threading = None
  34.  
  35. Signals = getcontext().flags.keys()
  36. DefaultContext.prec = 9
  37. DefaultContext.rounding = ROUND_HALF_EVEN
  38. DefaultContext.traps = dict.fromkeys(Signals, 0)
  39. setcontext(DefaultContext)
  40. TESTDATADIR = 'decimaltestdata'
  41. if __name__ == '__main__':
  42.     file = sys.argv[0]
  43. else:
  44.     file = __file__
  45. if not os.path.dirname(file):
  46.     pass
  47. testdir = os.curdir
  48. directory = testdir + os.sep + TESTDATADIR + os.sep
  49. skip_expected = not os.path.isdir(directory)
  50. EXTENDEDERRORTEST = False
  51. ErrorNames = {
  52.     'clamped': Clamped,
  53.     'conversion_syntax': InvalidOperation,
  54.     'division_by_zero': DivisionByZero,
  55.     'division_impossible': InvalidOperation,
  56.     'division_undefined': InvalidOperation,
  57.     'inexact': Inexact,
  58.     'invalid_context': InvalidOperation,
  59.     'invalid_operation': InvalidOperation,
  60.     'overflow': Overflow,
  61.     'rounded': Rounded,
  62.     'subnormal': Subnormal,
  63.     'underflow': Underflow }
  64.  
  65. def Nonfunction(*args):
  66.     """Doesn't do anything."""
  67.     pass
  68.  
  69. RoundingDict = {
  70.     'ceiling': ROUND_CEILING,
  71.     'down': ROUND_DOWN,
  72.     'floor': ROUND_FLOOR,
  73.     'half_down': ROUND_HALF_DOWN,
  74.     'half_even': ROUND_HALF_EVEN,
  75.     'half_up': ROUND_HALF_UP,
  76.     'up': ROUND_UP }
  77. nameAdapter = {
  78.     'toeng': 'to_eng_string',
  79.     'tosci': 'to_sci_string',
  80.     'samequantum': 'same_quantum',
  81.     'tointegral': 'to_integral',
  82.     'remaindernear': 'remainder_near',
  83.     'divideint': 'divide_int',
  84.     'squareroot': 'sqrt',
  85.     'apply': '_apply' }
  86.  
  87. class DecimalTest(unittest.TestCase):
  88.     '''Class which tests the Decimal class against the test cases.
  89.  
  90.     Changed for unittest.
  91.     '''
  92.     
  93.     def setUp(self):
  94.         self.context = Context()
  95.         for key in DefaultContext.traps.keys():
  96.             DefaultContext.traps[key] = 1
  97.         
  98.         self.ignore_list = [
  99.             '#']
  100.         self.ChangeDict = {
  101.             'precision': self.change_precision,
  102.             'rounding': self.change_rounding_method,
  103.             'maxexponent': self.change_max_exponent,
  104.             'minexponent': self.change_min_exponent,
  105.             'clamp': self.change_clamp }
  106.  
  107.     
  108.     def tearDown(self):
  109.         '''Cleaning up enviroment.'''
  110.         for key in DefaultContext.traps.keys():
  111.             DefaultContext.traps[key] = 0
  112.         
  113.  
  114.     
  115.     def eval_file(self, file):
  116.         if skip_expected:
  117.             raise TestSkipped
  118.             return None
  119.         
  120.         for line in open(file).xreadlines():
  121.             line = line.replace('\r\n', '').replace('\n', '')
  122.             
  123.             try:
  124.                 t = self.eval_line(line)
  125.             continue
  126.             except InvalidOperation:
  127.                 print 'Error in test cases:'
  128.                 print line
  129.                 continue
  130.                 continue
  131.                 except DecimalException:
  132.                     exception = None
  133.                     self.fail('Exception "' + exception.__class__.__name__ + '" raised on line ' + line)
  134.                     continue
  135.                 
  136.             return None
  137.  
  138.  
  139.     
  140.     def eval_line(self, s):
  141.         if s.find(' -> ') >= 0 and s[:2] != '--' and not s.startswith('  --'):
  142.             s = (s.split('->')[0] + '->' + s.split('->')[1].split('--')[0]).strip()
  143.         else:
  144.             s = s.split('--')[0].strip()
  145.         for ignore in self.ignore_list:
  146.             if s.find(ignore) >= 0:
  147.                 return None
  148.                 continue
  149.         
  150.         if not s:
  151.             return None
  152.         elif ':' in s:
  153.             return self.eval_directive(s)
  154.         else:
  155.             return self.eval_equation(s)
  156.  
  157.     
  158.     def eval_directive(self, s):
  159.         (funct, value) = map((lambda x: x.strip().lower()), s.split(':'))
  160.         if funct == 'rounding':
  161.             value = RoundingDict[value]
  162.         else:
  163.             
  164.             try:
  165.                 value = int(value)
  166.             except ValueError:
  167.                 pass
  168.  
  169.         funct = self.ChangeDict.get(funct, Nonfunction)
  170.         funct(value)
  171.  
  172.     
  173.     def eval_equation(self, s):
  174.         if not TEST_ALL and random.random() < 0.90000000000000002:
  175.             return None
  176.         
  177.         
  178.         try:
  179.             Sides = s.split('->')
  180.             L = Sides[0].strip().split()
  181.             id = L[0]
  182.             funct = L[1].lower()
  183.             valstemp = L[2:]
  184.             L = Sides[1].strip().split()
  185.             ans = L[0]
  186.             exceptions = L[1:]
  187.         except (TypeError, AttributeError, IndexError):
  188.             raise InvalidOperation
  189.  
  190.         
  191.         def FixQuotes(val):
  192.             val = val.replace("''", 'SingleQuote').replace('""', 'DoubleQuote')
  193.             val = val.replace("'", '').replace('"', '')
  194.             val = val.replace('SingleQuote', "'").replace('DoubleQuote', '"')
  195.             return val
  196.  
  197.         fname = nameAdapter.get(funct, funct)
  198.         if fname == 'rescale':
  199.             return None
  200.         
  201.         funct = getattr(self.context, fname)
  202.         vals = []
  203.         conglomerate = ''
  204.         quote = 0
  205.         theirexceptions = [ ErrorNames[x.lower()] for x in exceptions ]
  206.         for exception in Signals:
  207.             self.context.traps[exception] = 1
  208.         
  209.         for exception in theirexceptions:
  210.             self.context.traps[exception] = 0
  211.         
  212.         for i, val in enumerate(valstemp):
  213.             if quote:
  214.                 conglomerate = conglomerate + ' ' + val
  215.                 continue
  216.             else:
  217.                 val = conglomerate + val
  218.                 conglomerate = ''
  219.             v = FixQuotes(val)
  220.             if fname in ('to_sci_string', 'to_eng_string'):
  221.                 if EXTENDEDERRORTEST:
  222.                     for error in theirexceptions:
  223.                         self.context.traps[error] = 1
  224.                         
  225.                         try:
  226.                             funct(self.context.create_decimal(v))
  227.                         except error:
  228.                             pass
  229.                         except Signals:
  230.                             e = None
  231.                             self.fail('Raised %s in %s when %s disabled' % (e, s, error))
  232.  
  233.                         self.fail('Did not raise %s in %s' % (error, s))
  234.                         self.context.traps[error] = 0
  235.                     
  236.                 
  237.                 v = self.context.create_decimal(v)
  238.             else:
  239.                 v = Decimal(v)
  240.             vals.append(v)
  241.         
  242.         ans = FixQuotes(ans)
  243.         if EXTENDEDERRORTEST and fname not in ('to_sci_string', 'to_eng_string'):
  244.             for error in theirexceptions:
  245.                 self.context.traps[error] = 1
  246.                 
  247.                 try:
  248.                     funct(*vals)
  249.                 except error:
  250.                     pass
  251.                 except Signals:
  252.                     e = None
  253.                     self.fail('Raised %s in %s when %s disabled' % (e, s, error))
  254.  
  255.                 self.fail('Did not raise %s in %s' % (error, s))
  256.                 self.context.traps[error] = 0
  257.             
  258.         
  259.         
  260.         try:
  261.             result = str(funct(*vals))
  262.             if fname == 'same_quantum':
  263.                 result = str(int(eval(result)))
  264.         except Signals:
  265.             error = None
  266.             self.fail('Raised %s in %s' % (error, s))
  267.         except:
  268.             print 'ERROR:', s
  269.             raise 
  270.  
  271.         myexceptions = self.getexceptions()
  272.         self.context.clear_flags()
  273.         myexceptions.sort()
  274.         theirexceptions.sort()
  275.         self.assertEqual(result, ans, 'Incorrect answer for ' + s + ' -- got ' + result)
  276.         self.assertEqual(myexceptions, theirexceptions, 'Incorrect flags set in ' + s + ' -- got ' + str(myexceptions))
  277.  
  278.     
  279.     def getexceptions(self):
  280.         return _[1]
  281.  
  282.     
  283.     def change_precision(self, prec):
  284.         self.context.prec = prec
  285.  
  286.     
  287.     def change_rounding_method(self, rounding):
  288.         self.context.rounding = rounding
  289.  
  290.     
  291.     def change_min_exponent(self, exp):
  292.         self.context.Emin = exp
  293.  
  294.     
  295.     def change_max_exponent(self, exp):
  296.         self.context.Emax = exp
  297.  
  298.     
  299.     def change_clamp(self, clamp):
  300.         self.context._clamp = clamp
  301.  
  302.  
  303. for filename in os.listdir(directory):
  304.     if '.decTest' not in filename:
  305.         continue
  306.     
  307.     (head, tail) = filename.split('.')
  308.     
  309.     tester = lambda self, f = filename: self.eval_file(directory + f)
  310.     setattr(DecimalTest, 'test_' + head, tester)
  311.     del filename
  312.     del head
  313.     del tail
  314.     del tester
  315.  
  316.  
  317. class DecimalExplicitConstructionTest(unittest.TestCase):
  318.     '''Unit tests for Explicit Construction cases of Decimal.'''
  319.     
  320.     def test_explicit_empty(self):
  321.         self.assertEqual(Decimal(), Decimal('0'))
  322.  
  323.     
  324.     def test_explicit_from_None(self):
  325.         self.assertRaises(TypeError, Decimal, None)
  326.  
  327.     
  328.     def test_explicit_from_int(self):
  329.         d = Decimal(45)
  330.         self.assertEqual(str(d), '45')
  331.         d = Decimal(500000123)
  332.         self.assertEqual(str(d), '500000123')
  333.         d = Decimal(-45)
  334.         self.assertEqual(str(d), '-45')
  335.         d = Decimal(0)
  336.         self.assertEqual(str(d), '0')
  337.  
  338.     
  339.     def test_explicit_from_string(self):
  340.         self.assertEqual(str(Decimal('')), 'NaN')
  341.         self.assertEqual(str(Decimal('45')), '45')
  342.         self.assertEqual(str(Decimal('45.34')), '45.34')
  343.         self.assertEqual(str(Decimal('45e2')), '4.5E+3')
  344.         self.assertEqual(str(Decimal('ugly')), 'NaN')
  345.  
  346.     
  347.     def test_explicit_from_tuples(self):
  348.         d = Decimal((0, (0,), 0))
  349.         self.assertEqual(str(d), '0')
  350.         d = Decimal((1, (4, 5), 0))
  351.         self.assertEqual(str(d), '-45')
  352.         d = Decimal((0, (4, 5, 3, 4), -2))
  353.         self.assertEqual(str(d), '45.34')
  354.         d = Decimal((1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25))
  355.         self.assertEqual(str(d), '-4.34913534E-17')
  356.         self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)))
  357.         self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2))
  358.         self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!'))
  359.         self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2))
  360.         self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2))
  361.  
  362.     
  363.     def test_explicit_from_Decimal(self):
  364.         d = Decimal(45)
  365.         e = Decimal(d)
  366.         self.assertEqual(str(e), '45')
  367.         self.assertNotEqual(id(d), id(e))
  368.         d = Decimal(500000123)
  369.         e = Decimal(d)
  370.         self.assertEqual(str(e), '500000123')
  371.         self.assertNotEqual(id(d), id(e))
  372.         d = Decimal(-45)
  373.         e = Decimal(d)
  374.         self.assertEqual(str(e), '-45')
  375.         self.assertNotEqual(id(d), id(e))
  376.         d = Decimal(0)
  377.         e = Decimal(d)
  378.         self.assertEqual(str(e), '0')
  379.         self.assertNotEqual(id(d), id(e))
  380.  
  381.     
  382.     def test_explicit_context_create_decimal(self):
  383.         nc = copy.copy(getcontext())
  384.         nc.prec = 3
  385.         d = Decimal()
  386.         self.assertEqual(str(d), '0')
  387.         d = nc.create_decimal()
  388.         self.assertEqual(str(d), '0')
  389.         self.assertRaises(TypeError, nc.create_decimal, None)
  390.         d = nc.create_decimal(456)
  391.         self.failUnless(isinstance(d, Decimal))
  392.         self.assertEqual(nc.create_decimal(45678), nc.create_decimal('457E+2'))
  393.         d = Decimal('456789')
  394.         self.assertEqual(str(d), '456789')
  395.         d = nc.create_decimal('456789')
  396.         self.assertEqual(str(d), '4.57E+5')
  397.         d = Decimal((1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25))
  398.         self.assertEqual(str(d), '-4.34913534E-17')
  399.         d = nc.create_decimal((1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25))
  400.         self.assertEqual(str(d), '-4.35E-17')
  401.         prevdec = Decimal(500000123)
  402.         d = Decimal(prevdec)
  403.         self.assertEqual(str(d), '500000123')
  404.         d = nc.create_decimal(prevdec)
  405.         self.assertEqual(str(d), '5.00E+8')
  406.  
  407.  
  408.  
  409. class DecimalImplicitConstructionTest(unittest.TestCase):
  410.     '''Unit tests for Implicit Construction cases of Decimal.'''
  411.     
  412.     def test_implicit_from_None(self):
  413.         self.assertRaises(TypeError, eval, 'Decimal(5) + None', globals())
  414.  
  415.     
  416.     def test_implicit_from_int(self):
  417.         self.assertEqual(str(Decimal(5) + 45), '50')
  418.         self.assertEqual(Decimal(5) + 0x1CBE991A08L, Decimal(0x1CBE991A08L))
  419.  
  420.     
  421.     def test_implicit_from_string(self):
  422.         self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', globals())
  423.  
  424.     
  425.     def test_implicit_from_float(self):
  426.         self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', globals())
  427.  
  428.     
  429.     def test_implicit_from_Decimal(self):
  430.         self.assertEqual(Decimal(5) + Decimal(45), Decimal(50))
  431.  
  432.     
  433.     def test_rop(self):
  434.         
  435.         class E:
  436.             
  437.             def __divmod__(self, other):
  438.                 return 'divmod ' + str(other)
  439.  
  440.             
  441.             def __rdivmod__(self, other):
  442.                 return str(other) + ' rdivmod'
  443.  
  444.             
  445.             def __lt__(self, other):
  446.                 return 'lt ' + str(other)
  447.  
  448.             
  449.             def __gt__(self, other):
  450.                 return 'gt ' + str(other)
  451.  
  452.             
  453.             def __le__(self, other):
  454.                 return 'le ' + str(other)
  455.  
  456.             
  457.             def __ge__(self, other):
  458.                 return 'ge ' + str(other)
  459.  
  460.             
  461.             def __eq__(self, other):
  462.                 return 'eq ' + str(other)
  463.  
  464.             
  465.             def __ne__(self, other):
  466.                 return 'ne ' + str(other)
  467.  
  468.  
  469.         self.assertEqual(divmod(E(), Decimal(10)), 'divmod 10')
  470.         self.assertEqual(divmod(Decimal(10), E()), '10 rdivmod')
  471.         self.assertEqual(eval('Decimal(10) < E()'), 'gt 10')
  472.         self.assertEqual(eval('Decimal(10) > E()'), 'lt 10')
  473.         self.assertEqual(eval('Decimal(10) <= E()'), 'ge 10')
  474.         self.assertEqual(eval('Decimal(10) >= E()'), 'le 10')
  475.         self.assertEqual(eval('Decimal(10) == E()'), 'eq 10')
  476.         self.assertEqual(eval('Decimal(10) != E()'), 'ne 10')
  477.         for None in (('+', '__add__', '__radd__'), ('-', '__sub__', '__rsub__'), ('*', '__mul__', '__rmul__'), ('/', '__div__', '__rdiv__'), ('%', '__mod__', '__rmod__'), ('//', '__floordiv__', '__rfloordiv__'), ('**', '__pow__', '__rpow__')):
  478.             (sym, lop, rop) = None
  479.             setattr(E, rop, (lambda self, other: str(other) + rop + 'str'))
  480.             self.assertEqual(eval('E()' + sym + 'Decimal(10)'), 'str' + lop + '10')
  481.             self.assertEqual(eval('Decimal(10)' + sym + 'E()'), '10' + rop + 'str')
  482.         
  483.  
  484.  
  485.  
  486. class DecimalArithmeticOperatorsTest(unittest.TestCase):
  487.     '''Unit tests for all arithmetic operators, binary and unary.'''
  488.     
  489.     def test_addition(self):
  490.         d1 = Decimal('-11.1')
  491.         d2 = Decimal('22.2')
  492.         self.assertEqual(d1 + d2, Decimal('11.1'))
  493.         self.assertEqual(d2 + d1, Decimal('11.1'))
  494.         c = d1 + 5
  495.         self.assertEqual(c, Decimal('-6.1'))
  496.         self.assertEqual(type(c), type(d1))
  497.         c = 5 + d1
  498.         self.assertEqual(c, Decimal('-6.1'))
  499.         self.assertEqual(type(c), type(d1))
  500.         d1 += d2
  501.         self.assertEqual(d1, Decimal('11.1'))
  502.         d1 += 5
  503.         self.assertEqual(d1, Decimal('16.1'))
  504.  
  505.     
  506.     def test_subtraction(self):
  507.         d1 = Decimal('-11.1')
  508.         d2 = Decimal('22.2')
  509.         self.assertEqual(d1 - d2, Decimal('-33.3'))
  510.         self.assertEqual(d2 - d1, Decimal('33.3'))
  511.         c = d1 - 5
  512.         self.assertEqual(c, Decimal('-16.1'))
  513.         self.assertEqual(type(c), type(d1))
  514.         c = 5 - d1
  515.         self.assertEqual(c, Decimal('16.1'))
  516.         self.assertEqual(type(c), type(d1))
  517.         d1 -= d2
  518.         self.assertEqual(d1, Decimal('-33.3'))
  519.         d1 -= 5
  520.         self.assertEqual(d1, Decimal('-38.3'))
  521.  
  522.     
  523.     def test_multiplication(self):
  524.         d1 = Decimal('-5')
  525.         d2 = Decimal('3')
  526.         self.assertEqual(d1 * d2, Decimal('-15'))
  527.         self.assertEqual(d2 * d1, Decimal('-15'))
  528.         c = d1 * 5
  529.         self.assertEqual(c, Decimal('-25'))
  530.         self.assertEqual(type(c), type(d1))
  531.         c = 5 * d1
  532.         self.assertEqual(c, Decimal('-25'))
  533.         self.assertEqual(type(c), type(d1))
  534.         d1 *= d2
  535.         self.assertEqual(d1, Decimal('-15'))
  536.         d1 *= 5
  537.         self.assertEqual(d1, Decimal('-75'))
  538.  
  539.     
  540.     def test_division(self):
  541.         d1 = Decimal('-5')
  542.         d2 = Decimal('2')
  543.         self.assertEqual(d1 / d2, Decimal('-2.5'))
  544.         self.assertEqual(d2 / d1, Decimal('-0.4'))
  545.         c = d1 / 4
  546.         self.assertEqual(c, Decimal('-1.25'))
  547.         self.assertEqual(type(c), type(d1))
  548.         c = 4 / d1
  549.         self.assertEqual(c, Decimal('-0.8'))
  550.         self.assertEqual(type(c), type(d1))
  551.         d1 /= d2
  552.         self.assertEqual(d1, Decimal('-2.5'))
  553.         d1 /= 4
  554.         self.assertEqual(d1, Decimal('-0.625'))
  555.  
  556.     
  557.     def test_floor_division(self):
  558.         d1 = Decimal('5')
  559.         d2 = Decimal('2')
  560.         self.assertEqual(d1 // d2, Decimal('2'))
  561.         self.assertEqual(d2 // d1, Decimal('0'))
  562.         c = d1 // 4
  563.         self.assertEqual(c, Decimal('1'))
  564.         self.assertEqual(type(c), type(d1))
  565.         c = 7 // d1
  566.         self.assertEqual(c, Decimal('1'))
  567.         self.assertEqual(type(c), type(d1))
  568.         d1 //= d2
  569.         self.assertEqual(d1, Decimal('2'))
  570.         d1 //= 2
  571.         self.assertEqual(d1, Decimal('1'))
  572.  
  573.     
  574.     def test_powering(self):
  575.         d1 = Decimal('5')
  576.         d2 = Decimal('2')
  577.         self.assertEqual(d1 ** d2, Decimal('25'))
  578.         self.assertEqual(d2 ** d1, Decimal('32'))
  579.         c = d1 ** 4
  580.         self.assertEqual(c, Decimal('625'))
  581.         self.assertEqual(type(c), type(d1))
  582.         c = 7 ** d1
  583.         self.assertEqual(c, Decimal('16807'))
  584.         self.assertEqual(type(c), type(d1))
  585.         d1 **= d2
  586.         self.assertEqual(d1, Decimal('25'))
  587.         d1 **= 4
  588.         self.assertEqual(d1, Decimal('390625'))
  589.  
  590.     
  591.     def test_module(self):
  592.         d1 = Decimal('5')
  593.         d2 = Decimal('2')
  594.         self.assertEqual(d1 % d2, Decimal('1'))
  595.         self.assertEqual(d2 % d1, Decimal('2'))
  596.         c = d1 % 4
  597.         self.assertEqual(c, Decimal('1'))
  598.         self.assertEqual(type(c), type(d1))
  599.         c = 7 % d1
  600.         self.assertEqual(c, Decimal('2'))
  601.         self.assertEqual(type(c), type(d1))
  602.         d1 %= d2
  603.         self.assertEqual(d1, Decimal('1'))
  604.         d1 %= 4
  605.         self.assertEqual(d1, Decimal('1'))
  606.  
  607.     
  608.     def test_floor_div_module(self):
  609.         d1 = Decimal('5')
  610.         d2 = Decimal('2')
  611.         (p, q) = divmod(d1, d2)
  612.         self.assertEqual(p, Decimal('2'))
  613.         self.assertEqual(q, Decimal('1'))
  614.         self.assertEqual(type(p), type(d1))
  615.         self.assertEqual(type(q), type(d1))
  616.         (p, q) = divmod(d1, 4)
  617.         self.assertEqual(p, Decimal('1'))
  618.         self.assertEqual(q, Decimal('1'))
  619.         self.assertEqual(type(p), type(d1))
  620.         self.assertEqual(type(q), type(d1))
  621.         (p, q) = divmod(7, d1)
  622.         self.assertEqual(p, Decimal('1'))
  623.         self.assertEqual(q, Decimal('2'))
  624.         self.assertEqual(type(p), type(d1))
  625.         self.assertEqual(type(q), type(d1))
  626.  
  627.     
  628.     def test_unary_operators(self):
  629.         self.assertEqual(+Decimal(45), Decimal(45))
  630.         self.assertEqual(-Decimal(45), Decimal(-45))
  631.         self.assertEqual(abs(Decimal(45)), abs(Decimal(-45)))
  632.  
  633.  
  634.  
  635. def thfunc1(cls):
  636.     d1 = Decimal(1)
  637.     d3 = Decimal(3)
  638.     cls.assertEqual(d1 / d3, Decimal('0.333333333'))
  639.     cls.synchro.wait()
  640.     cls.assertEqual(d1 / d3, Decimal('0.333333333'))
  641.     cls.finish1.set()
  642.  
  643.  
  644. def thfunc2(cls):
  645.     d1 = Decimal(1)
  646.     d3 = Decimal(3)
  647.     cls.assertEqual(d1 / d3, Decimal('0.333333333'))
  648.     thiscontext = getcontext()
  649.     thiscontext.prec = 18
  650.     cls.assertEqual(d1 / d3, Decimal('0.333333333333333333'))
  651.     cls.synchro.set()
  652.     cls.finish2.set()
  653.  
  654.  
  655. class DecimalUseOfContextTest(unittest.TestCase):
  656.     '''Unit tests for Use of Context cases in Decimal.'''
  657.     
  658.     try:
  659.         import threading
  660.     except ImportError:
  661.         threading = None
  662.  
  663.     
  664.     def test_threading(self):
  665.         self.synchro = threading.Event()
  666.         self.finish1 = threading.Event()
  667.         self.finish2 = threading.Event()
  668.         th1 = threading.Thread(target = thfunc1, args = (self,))
  669.         th2 = threading.Thread(target = thfunc2, args = (self,))
  670.         th1.start()
  671.         th2.start()
  672.         self.finish1.wait()
  673.         self.finish1.wait()
  674.  
  675.     if threading is None:
  676.         del test_threading
  677.     
  678.  
  679.  
  680. class DecimalUsabilityTest(unittest.TestCase):
  681.     '''Unit tests for Usability cases of Decimal.'''
  682.     
  683.     def test_comparison_operators(self):
  684.         da = Decimal('23.42')
  685.         db = Decimal('23.42')
  686.         dc = Decimal('45')
  687.         self.failUnless(dc > da)
  688.         self.failUnless(dc >= da)
  689.         self.failUnless(da < dc)
  690.         self.failUnless(da <= dc)
  691.         self.failUnless(da == db)
  692.         self.failUnless(da != dc)
  693.         self.failUnless(da <= db)
  694.         self.failUnless(da >= db)
  695.         self.assertEqual(cmp(dc, da), 1)
  696.         self.assertEqual(cmp(da, dc), -1)
  697.         self.assertEqual(cmp(da, db), 0)
  698.         self.failUnless(dc > 23)
  699.         self.failUnless(23 < dc)
  700.         self.failUnless(dc == 45)
  701.         self.assertEqual(cmp(dc, 23), 1)
  702.         self.assertEqual(cmp(23, dc), -1)
  703.         self.assertEqual(cmp(dc, 45), 0)
  704.         self.assertNotEqual(da, 'ugly')
  705.         self.assertNotEqual(da, 32.700000000000003)
  706.         self.assertNotEqual(da, object())
  707.         self.assertNotEqual(da, object)
  708.         a = map(Decimal, xrange(100))
  709.         b = a[:]
  710.         random.shuffle(a)
  711.         a.sort()
  712.         self.assertEqual(a, b)
  713.  
  714.     
  715.     def test_copy_and_deepcopy_methods(self):
  716.         d = Decimal('43.24')
  717.         c = copy.copy(d)
  718.         self.assertEqual(id(c), id(d))
  719.         dc = copy.deepcopy(d)
  720.         self.assertEqual(id(dc), id(d))
  721.  
  722.     
  723.     def test_hash_method(self):
  724.         hash(Decimal(23))
  725.         self.assertEqual(hash(Decimal(23)), hash(23))
  726.         self.assertRaises(TypeError, hash, Decimal('NaN'))
  727.         self.assert_(hash(Decimal('Inf')))
  728.         self.assert_(hash(Decimal('-Inf')))
  729.  
  730.     
  731.     def test_min_and_max_methods(self):
  732.         d1 = Decimal('15.32')
  733.         d2 = Decimal('28.5')
  734.         l1 = 15
  735.         l2 = 28
  736.         self.failUnless(min(d1, d2) is d1)
  737.         self.failUnless(min(d2, d1) is d1)
  738.         self.failUnless(max(d1, d2) is d2)
  739.         self.failUnless(max(d2, d1) is d2)
  740.         self.failUnless(min(d1, l2) is d1)
  741.         self.failUnless(min(l2, d1) is d1)
  742.         self.failUnless(max(l1, d2) is d2)
  743.         self.failUnless(max(d2, l1) is d2)
  744.  
  745.     
  746.     def test_as_nonzero(self):
  747.         self.failIf(Decimal(0))
  748.         self.failUnless(Decimal('0.372'))
  749.  
  750.     
  751.     def test_tostring_methods(self):
  752.         d = Decimal('15.32')
  753.         self.assertEqual(str(d), '15.32')
  754.         self.assertEqual(repr(d), 'Decimal("15.32")')
  755.  
  756.     
  757.     def test_tonum_methods(self):
  758.         d1 = Decimal('66')
  759.         d2 = Decimal('15.32')
  760.         self.assertEqual(int(d1), 66)
  761.         self.assertEqual(int(d2), 15)
  762.         self.assertEqual(long(d1), 66)
  763.         self.assertEqual(long(d2), 15)
  764.         self.assertEqual(float(d1), 66)
  765.         self.assertEqual(float(d2), 15.32)
  766.  
  767.     
  768.     def test_eval_round_trip(self):
  769.         d = Decimal((0, (0,), 0))
  770.         self.assertEqual(d, eval(repr(d)))
  771.         d = Decimal((1, (4, 5), 0))
  772.         self.assertEqual(d, eval(repr(d)))
  773.         d = Decimal((0, (4, 5, 3, 4), -2))
  774.         self.assertEqual(d, eval(repr(d)))
  775.         d = Decimal((1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25))
  776.         self.assertEqual(d, eval(repr(d)))
  777.  
  778.     
  779.     def test_as_tuple(self):
  780.         d = Decimal(0)
  781.         self.assertEqual(d.as_tuple(), (0, (0,), 0))
  782.         d = Decimal(-45)
  783.         self.assertEqual(d.as_tuple(), (1, (4, 5), 0))
  784.         d = Decimal('-4.34913534E-17')
  785.         self.assertEqual(d.as_tuple(), (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25))
  786.         d = Decimal('Infinity')
  787.         self.assertEqual(d.as_tuple(), (0, (0,), 'F'))
  788.  
  789.     
  790.     def test_immutability_operations(self):
  791.         d1 = Decimal('-25e55')
  792.         b1 = Decimal('-25e55')
  793.         d2 = Decimal('33e-33')
  794.         b2 = Decimal('33e-33')
  795.         
  796.         def checkSameDec(operation, useOther = False):
  797.             if useOther:
  798.                 eval('d1.' + operation + '(d2)')
  799.                 self.assertEqual(d1._sign, b1._sign)
  800.                 self.assertEqual(d1._int, b1._int)
  801.                 self.assertEqual(d1._exp, b1._exp)
  802.                 self.assertEqual(d2._sign, b2._sign)
  803.                 self.assertEqual(d2._int, b2._int)
  804.                 self.assertEqual(d2._exp, b2._exp)
  805.             else:
  806.                 eval('d1.' + operation + '()')
  807.                 self.assertEqual(d1._sign, b1._sign)
  808.                 self.assertEqual(d1._int, b1._int)
  809.                 self.assertEqual(d1._exp, b1._exp)
  810.  
  811.         Decimal(d1)
  812.         self.assertEqual(d1._sign, b1._sign)
  813.         self.assertEqual(d1._int, b1._int)
  814.         self.assertEqual(d1._exp, b1._exp)
  815.         checkSameDec('__abs__')
  816.         checkSameDec('__add__', True)
  817.         checkSameDec('__div__', True)
  818.         checkSameDec('__divmod__', True)
  819.         checkSameDec('__cmp__', True)
  820.         checkSameDec('__float__')
  821.         checkSameDec('__floordiv__', True)
  822.         checkSameDec('__hash__')
  823.         checkSameDec('__int__')
  824.         checkSameDec('__long__')
  825.         checkSameDec('__mod__', True)
  826.         checkSameDec('__mul__', True)
  827.         checkSameDec('__neg__')
  828.         checkSameDec('__nonzero__')
  829.         checkSameDec('__pos__')
  830.         checkSameDec('__pow__', True)
  831.         checkSameDec('__radd__', True)
  832.         checkSameDec('__rdiv__', True)
  833.         checkSameDec('__rdivmod__', True)
  834.         checkSameDec('__repr__')
  835.         checkSameDec('__rfloordiv__', True)
  836.         checkSameDec('__rmod__', True)
  837.         checkSameDec('__rmul__', True)
  838.         checkSameDec('__rpow__', True)
  839.         checkSameDec('__rsub__', True)
  840.         checkSameDec('__str__')
  841.         checkSameDec('__sub__', True)
  842.         checkSameDec('__truediv__', True)
  843.         checkSameDec('adjusted')
  844.         checkSameDec('as_tuple')
  845.         checkSameDec('compare', True)
  846.         checkSameDec('max', True)
  847.         checkSameDec('min', True)
  848.         checkSameDec('normalize')
  849.         checkSameDec('quantize', True)
  850.         checkSameDec('remainder_near', True)
  851.         checkSameDec('same_quantum', True)
  852.         checkSameDec('sqrt')
  853.         checkSameDec('to_eng_string')
  854.         checkSameDec('to_integral')
  855.  
  856.  
  857.  
  858. class DecimalPythonAPItests(unittest.TestCase):
  859.     
  860.     def test_pickle(self):
  861.         d = Decimal('-3.141590000')
  862.         p = pickle.dumps(d)
  863.         e = pickle.loads(p)
  864.         self.assertEqual(d, e)
  865.  
  866.     
  867.     def test_int(self):
  868.         for x in range(-250, 250):
  869.             s = '%0.2f' % x / 100.0
  870.             self.assertEqual(int(Decimal(s)), int(float(s)))
  871.             d = Decimal(s)
  872.             r = d.to_integral(ROUND_DOWN)
  873.             self.assertEqual(Decimal(int(d)), r)
  874.         
  875.  
  876.  
  877.  
  878. class ContextAPItests(unittest.TestCase):
  879.     
  880.     def test_pickle(self):
  881.         c = Context()
  882.         e = pickle.loads(pickle.dumps(c))
  883.         for k in vars(c):
  884.             v1 = vars(c)[k]
  885.             v2 = vars(e)[k]
  886.             self.assertEqual(v1, v2)
  887.         
  888.  
  889.     
  890.     def test_equality_with_other_types(self):
  891.         self.assert_(Decimal(10) in [
  892.             'a',
  893.             1.0,
  894.             Decimal(10),
  895.             (1, 2),
  896.             { }])
  897.         self.assert_(Decimal(10) not in [
  898.             'a',
  899.             1.0,
  900.             (1, 2),
  901.             { }])
  902.  
  903.     
  904.     def test_copy(self):
  905.         c = Context()
  906.         d = c.copy()
  907.         self.assertNotEqual(id(c), id(d))
  908.         self.assertNotEqual(id(c.flags), id(d.flags))
  909.         self.assertNotEqual(id(c.traps), id(d.traps))
  910.  
  911.  
  912.  
  913. def test_main(arith = False, verbose = None):
  914.     ''' Execute the tests.
  915.  
  916.     Runs all arithmetic tests if arith is True or if the "decimal" resource
  917.     is enabled in regrtest.py
  918.     '''
  919.     global TEST_ALL
  920.     if not arith:
  921.         pass
  922.     TEST_ALL = is_resource_enabled('decimal')
  923.     test_classes = [
  924.         DecimalExplicitConstructionTest,
  925.         DecimalImplicitConstructionTest,
  926.         DecimalArithmeticOperatorsTest,
  927.         DecimalUseOfContextTest,
  928.         DecimalUsabilityTest,
  929.         DecimalPythonAPItests,
  930.         ContextAPItests,
  931.         DecimalTest]
  932.     run_unittest(*test_classes)
  933.     import decimal as DecimalModule
  934.     run_doctest(DecimalModule, verbose)
  935.  
  936. if __name__ == '__main__':
  937.     if len(sys.argv) == 1:
  938.         test_main(arith = True, verbose = True)
  939.     elif len(sys.argv) == 2:
  940.         arith = sys.argv[1].lower() != 'skip'
  941.         test_main(arith = arith, verbose = True)
  942.     else:
  943.         raise ValueError('test called with wrong arguments, use test_Decimal [Skip]')
  944.  
  945.